home *** CD-ROM | disk | FTP | other *** search
/ Internet Surfer: Getting Started / Internet Surfer - Getting Started (Wayzata Technology)(7231)(1995).bin / pc / mac / bonus / peter_le / finger-1 / my_units / myoomain.p < prev    next >
Text File  |  1992-02-24  |  20KB  |  780 lines
  1. unit OOMainLoop;
  2.  
  3. { This code is part of the Finger/Fingerd source code, written in THINK Pascal 4 }
  4. { Copyright 1991-1992 Peter N Lewis }
  5. { If you use this code, you must give me credit in your about box and documentation }
  6. { This is part of my generic library of routines }
  7.  
  8. interface
  9.  
  10.     const
  11.         WT_NotMine = 'NtMe';
  12.         WT_Generic = 'Genr';
  13.  
  14.     type
  15.         SCType = (SCSave, SCCancel, SCDiscard);
  16.         WObject = object
  17.                 window: dialogPtr;
  18.                 window_type: OSType;
  19.                 growRect: rect; { minimum/maximum rect size (for use with grow window) }
  20.                 zoomSize: point; { Optimum zoom size }
  21.                 procedure Create (id: integer);
  22.                 procedure Destroy;
  23.                 function SaveChanges: SCType;
  24.                 procedure DoClose;
  25. { DoClose checks modified things etc, then calls Destroy }
  26.                 function SetMenuBar: boolean;
  27.                 function EditMenuEnabled: boolean;
  28.                 procedure SetEditMenuItem (item: integer);
  29.                 procedure DoEditMenu (item: integer);
  30.                 function DoMenuKey (er: eventRecord; ch: char): longInt;
  31.                 procedure CalculateRegion (var rgn: rgnHandle);
  32.                 function WaitForEvent (var er: eventRecord; sleep: longInt): boolean;
  33.                 procedure DoIdle;
  34.                 procedure DoDiskEvent (message: longInt);
  35.                 procedure DoSuspendResume (resume: boolean);
  36.                 procedure DoHighLevel (er: eventRecord);
  37.                 procedure DoContent (where: point);
  38.                 procedure DoKey (modifiers: integer; ch: char; code: integer);
  39.                 procedure DoSpecialKey (modifiers: integer; ch: char; code: integer);
  40.                 procedure DoAutoKey (modifiers: integer; ch: char; code: integer);
  41.                 procedure DoDrag (where: point);
  42.                 procedure DoGrow (where: point);
  43.                 procedure Zoom (code: integer);
  44.                 procedure DoZoom (where: point; code: integer);
  45.                 procedure DoGoAway (where: point);
  46.                 procedure DoUpdate;
  47.                 procedure DoMouseMoved (where: point);
  48.                 procedure DoActivateDeactivate (activate: boolean);
  49.                 procedure Resize;
  50.                 procedure Draw;
  51.                 function DoMainClick (er: eventRecord): boolean;
  52.                 function DoIsDialogEvent (er: eventRecord): boolean;
  53.                 function DoDialogSelect (er: eventRecord; var dlg: dialogPtr; var item: integer): boolean;
  54.                 function HandleEvents (er: eventRecord): boolean;
  55.             end;
  56.         DObject = object(WObject)
  57.                 ok_item, cancel_item: integer;
  58.                 procedure Create (id: integer);
  59.                 override;
  60.                 procedure Destroy;
  61.                 override;
  62.                 function HandleEvents (er: eventRecord): boolean;
  63.                 override;
  64.                 procedure DoItem (item: integer);
  65.                 procedure DoItemWhere (er: eventRecord; item: integer);
  66.                 procedure DoCancel (modifiers: integer; ch: char; code: integer);
  67.                 procedure DoOK (modifiers: integer; ch: char; code: integer);
  68.             end;
  69.         DTObject = object(DObject)
  70.                 procedure SetEditMenuItem (item: integer);
  71.                 override;
  72.                 function EditMenuEnabled: boolean;
  73.                 override;
  74.                 procedure DoEditMenu (item: integer);
  75.                 override;
  76.                 function DoIsDialogEvent (er: eventRecord): boolean;
  77.                 override;
  78.             end;
  79.  
  80.     var
  81.         default_object: WObject;
  82.  
  83.     function GetWType (wp: windowPtr): OSType;
  84.     function GetWObject (wp: windowPtr): WObject;
  85.     function GetDObject (dlg: dialogPtr): DObject;
  86.     function FrontObject: WObject;
  87.     function IsWObjectFront (o: WObject): boolean;
  88.     procedure InitMainLoop (dobj: DObject; domenu: procptr);
  89. { dobj will be used returned with window set to wp whenever GetWObject/GetDObject is called with a DA or nil window }
  90.     procedure FinishMainLoop;
  91. {    procedure DoMenu (themenu, theitem: integer);}
  92.  
  93. implementation
  94.  
  95.     uses
  96.         Script, MyUtils, MyUtilities, MyTypes, MyFMenus, BaseGlobals, MyTEUtils;
  97.  
  98.     type
  99.         WStateDataPtr = ^WStateData;
  100.         WStateDataHandle = ^WStateDataPtr;
  101.  
  102.     const
  103. { from EPPC }
  104.         kHighLevelEvent = 23;
  105.         OOMagic = 'MyOO';
  106.  
  107.     type
  108.         myWindowRecord = record
  109.                 thewindow: windowRecord;
  110.                 magic: OSType;
  111.             end;
  112.         myWindowPtr = ^myWindowRecord;
  113.         myDialogRecord = record
  114.                 thedialog: dialogRecord;
  115.                 magic: OSType;
  116.             end;
  117.         myDialogPtr = ^myDialogRecord;
  118.  
  119. { from AppleEvents }
  120.     function AEProcessAppleEvent (theEventRecord: EventRecord): OSErr;
  121.     inline
  122.         $303C, $021B, $A816;
  123.  
  124.     var
  125.         domenup: procptr;
  126.  
  127.     procedure DoMenu (themenu, theitem: integer; domenu: procptr);
  128.     inline
  129.         $205F, $4E90;
  130.  
  131. {$S Init}
  132.     procedure InitMainLoop (dobj: DObject; domenu: procptr);
  133.         var
  134.             i: integer;
  135.             dummy: boolean;
  136.             dummy_er: eventRecord;
  137.     begin
  138.         for i := 1 to 5 do
  139.             dummy := EventAvail(everyEvent, dummy_er);
  140.         domenup := domenu;
  141.         default_object := dobj;
  142.     end;
  143.  
  144. {$S Term}
  145.     procedure FinishMainLoop;
  146.     begin
  147.         dispose(default_object);
  148.     end;
  149.  
  150. {$S}
  151.     function GetWRC (wp: windowPtr): WObject;
  152.         var
  153.             rc: longInt;
  154.     begin
  155.         if wp = nil then
  156.             rc := 0
  157.         else if windowPeek(wp)^.windowKind < 0 then
  158.             rc := 0
  159.         else if windowPeek(wp)^.windowKind = dialogKind then
  160.             if myDialogPtr(wp)^.magic = OOMagic then
  161.                 rc := GetWRefCon(wp)
  162.             else
  163.                 rc := 0
  164.         else if myWindowPtr(wp)^.magic = OOMagic then
  165.             rc := GetWRefCon(wp)
  166.         else
  167.             rc := 0;
  168.         if rc = 0 then begin
  169.             default_object.window := wp;
  170.             rc := longInt(default_object);
  171.         end;
  172.         GetWRC := WObject(rc);
  173.     end;
  174.  
  175.     function GetWType (wp: windowPtr): OSType;
  176.         var
  177.             wo: WObject;
  178.     begin
  179.         wo := GetWRC(wp);
  180.         if wo = default_object then
  181.             GetWType := WT_NotMine
  182.         else
  183.             GetWType := wo.window_type;
  184.     end;
  185.  
  186.     function GetWObject (wp: windowPtr): WObject;
  187.     begin
  188.         GetWObject := GetWRC(wp);
  189.     end;
  190.  
  191.     function GetDObject (dlg: dialogPtr): DObject;
  192.     begin
  193.         GetDObject := DObject(GetWRC(dlg));
  194.     end;
  195.  
  196.     function FrontObject: WObject;
  197.     begin
  198.         FrontObject := GetWRC(FrontWindow);
  199.     end;
  200.  
  201.     function IsWObjectFront (o: WObject): boolean;
  202.     begin
  203.         if o = nil then
  204.             IsWObjectFront := false
  205.         else if o.window = nil then
  206.             IsWObjectFront := false
  207.         else
  208.             IsWObjectFront := o.window = FrontWindow;
  209.     end;
  210.  
  211.     function WObject.SaveChanges: SCType;
  212.         var
  213.             a: integer;
  214.             title: str255;
  215.     begin
  216.         SelectWindow(window);
  217.         GetWTitle(window, title);
  218.         if quitNow then
  219.             ParamText(title, GetGlobalString(quiting_str), '', '')
  220.         else
  221.             ParamText(title, GetGlobalString(closing_str), '', '');
  222.         SetCursor(arrow);
  223.         a := Alert(save_changes_alert_id, nil);
  224.         SaveChanges := SCType(a - 1);
  225.     end;
  226.  
  227.     function WObject.EditMenuEnabled: boolean;
  228.     begin
  229.         if window = nil then
  230.             EditMenuEnabled := false
  231.         else
  232.             EditMenuEnabled := windowPeek(window)^.windowKind < 0
  233.     end;
  234.  
  235.     function WObject.SetMenuBar: boolean;
  236.         var
  237.             oldEditEnabled, editEnabled: boolean;
  238.     begin
  239.         oldEditEnabled := GetIDItemEnable(M_Edit, 0);
  240.         editEnabled := FrontObject.EditMenuEnabled;
  241.         if editEnabled <> oldEditEnabled then
  242.             SetIDItemEnable(M_Edit, 0, editEnabled);
  243.         SetMenuBar := editEnabled <> oldEditEnabled;
  244.     end;
  245.  
  246.     procedure WObject.SetEditMenuItem (item: integer);
  247.     begin
  248.     end;
  249.  
  250.     procedure WObject.DoEditMenu (item: integer);
  251.         var
  252.             dummyb: boolean;
  253.     begin
  254.         if item <= 6 then
  255.             dummyb := SystemEdit(item - 1);
  256.     end;
  257.  
  258.     function WObject.DoMenuKey (er: eventRecord; ch: char): longInt;
  259.         const
  260.             kMaskVirtualKey = $0000FF00; {get virtual key from event message}
  261.             kMaskASCII1 = $00FF0000;
  262.             kMaskASCII2 = $000000FF; {get key from KeyTrans return}
  263.             kKeyUpMask = $0080;
  264.         var
  265.             h: handle;
  266.             virtualKey, keyCId, state, keyInfo: longInt;
  267.             keycode: integer;
  268.             lowchar, highchar: integer;
  269.     begin
  270.         if BAND(er.modifiers, optionKey) <> 0 then begin
  271.             virtualKey := BSR(BAND(er.message, kMaskVirtualKey), 8);
  272.             keyCode := BOR(BOR(BXOR(er.modifiers, optionKey), kKeyUpMask), virtualKey);
  273.             state := 0;
  274.  
  275.             keyCId := GetScript(GetEnvirons(smKeyScript), smScriptKeys);
  276.             h := GetResource('KCHR', keyCId);
  277.  
  278.             if h <> nil then begin
  279. { we don't need to lock the resource since KeyTrans}
  280. {    will not move memory }
  281.                 keyInfo := KeyTrans(h^, keyCode, state);
  282.                 ReleaseResource(h);
  283.                 LowChar := BAND(keyInfo, $FF);
  284.                 HighChar := BAND(BSR(keyInfo, 16), $FF);
  285.                 if lowChar <> 0 then
  286.                     ch := chr(lowChar);
  287.                 if highChar <> 0 then
  288.                     ch := chr(highChar);
  289.             end;
  290.         end;
  291.         DoMenuKey := MenuKey(ch);
  292.     end;
  293.  
  294.     procedure WObject.CalculateRegion (var rgn: rgnHandle);
  295.     begin
  296.         rgn := nil;
  297.     end;
  298.  
  299.     function WObject.WaitForEvent (var er: eventRecord; sleep: longInt): boolean;
  300.         var
  301.             rgn: rgnHandle;
  302.             b: boolean;
  303.     begin
  304.         CalculateRegion(rgn);
  305.         WaitForEvent := WaitGetNextEvent(everyEvent, er, sleep, rgn);
  306.         if rgn <> nil then
  307.             DisposeRgn(rgn);
  308.     end;
  309.  
  310.     procedure WObject.DoDiskEvent (message: longInt);
  311.         var
  312.             pt: point;
  313.             oe: OSErr;
  314.     begin
  315.         if (HiWord(message) <> noErr) then begin
  316.             pt.h := ((screenbits.bounds.Right - screenbits.bounds.Left - 304) div 2);
  317.             pt.v := ((screenbits.bounds.Bottom - screenbits.bounds.Top - 156) div 3);
  318.             InitCursor;
  319.             oe := DIBadMount(pt, message);
  320.         end;
  321.     end;
  322.  
  323.     procedure WObject.DoSuspendResume (resume: boolean);
  324.     begin
  325.         in_foreground := resume;
  326.         FrontObject.DoActivateDeactivate(resume);
  327.         InitCursor;
  328.     end;
  329.  
  330.     procedure WObject.DoHighLevel (er: eventRecord);
  331.         var
  332.             oe: OSErr;
  333.     begin
  334.         if has_AppleEvents then
  335.             oe := AEProcessAppleEvent(er);
  336.     end;
  337.  
  338.     procedure JointCreate (o: WObject);
  339.     begin
  340.         SetWRefCon(o.window, longInt(o));
  341.         o.growRect := GetGrayRgn^^.rgnBBox;
  342.         o.growRect.left := 61;
  343.         o.growRect.top := 61;
  344.         o.zoomSize.h := 30000;
  345.         o.zoomSize.v := 30000;
  346.         o.window_type := WT_Generic;
  347.     end;
  348.  
  349.     procedure WObject.Create (id: integer);
  350.         var
  351.             wp: myWindowPtr;
  352.     begin
  353.         wp := myWindowPtr(NewPtr(SizeOf(myWindowRecord)));
  354.         wp^.magic := OOMagic;
  355.         window := GetNewWindow(id, ptr(wp), POINTER(-1));
  356.         JointCreate(self);
  357.     end;
  358.  
  359.     procedure WObject.Destroy;
  360.     begin
  361.         if window <> nil then
  362.             DisposeWindow(window);
  363.         if self <> default_object then
  364.             dispose(self);
  365.     end;
  366.  
  367.     procedure WObject.DoClose;
  368.     begin
  369.         Destroy;
  370.     end;
  371.  
  372.     procedure WObject.DoContent (where: point);
  373.     begin
  374.     end;
  375.  
  376.     procedure WObject.DoKey (modifiers: integer; ch: char; code: integer);
  377.     begin
  378.         SysBeep(1);
  379.     end;
  380.  
  381.     procedure WObject.DoSpecialKey (modifiers: integer; ch: char; code: integer);
  382.         var
  383.             item: integer;
  384.     begin
  385.         case code of
  386.             undoKey: 
  387.                 item := EMundo;
  388.             cutKey: 
  389.                 item := EMcut;
  390.             copyKey: 
  391.                 item := EMcopy;
  392.             pasteKey: 
  393.                 item := EMpaste;
  394.             clearKey: 
  395.                 item := EMclear;
  396.             otherwise
  397.                 item := -1;
  398.         end;
  399.         if item <> -1 then begin
  400.             SetFMenus;
  401.             if not GetIDItemEnable(M_Edit, 0) or not GetIDItemEnable(M_Edit, item) then
  402.                 item := -1;
  403.         end;
  404.         if item = -1 then
  405.             DoKey(modifiers, ch, code)
  406.         else
  407.             DoMenu(M_Edit, item, domenup);
  408.     end;
  409.  
  410.     procedure WObject.DoAutoKey (modifiers: integer; ch: char; code: integer);
  411.     begin
  412.     end;
  413.  
  414.     procedure WObject.DoDrag (where: point);
  415.         var
  416.             temprect: rect;
  417.             bnds1, bnds2: point;
  418.     begin
  419.         tempRect := GetGrayRgn^^.rgnBBox;
  420.         bnds1 := window^.portBits.bounds.topleft;
  421.         DragWindow(window, where, tempRect);
  422.         bnds2 := window^.portBits.bounds.topleft;
  423.         OffsetRect(WStateDataHandle(WindowPeek(window)^.dataHandle)^^.stdState, bnds1.h - bnds2.h, bnds1.v - bnds2.v);
  424. {    OffsetRect(WStateDataHandle(WindowPeek(window)^.dataHandle)^^.userState, bnds1.h - bnds2.h, bnds1.v - bnds2.v);}
  425.     end;
  426.  
  427.     procedure WObject.DoGrow (where: point);
  428.         var
  429.             mypt: point;
  430.             oldrect: rect;
  431.             mResult: longInt;
  432.             tempRect: rect;
  433.     begin
  434.         SetPort(window);
  435.         myPt := where;
  436.         GlobalToLocal(myPt);
  437.         oldrect := window^.portRect;
  438.         mResult := GrowWindow(window, where, growRect);
  439.         SizeWindow(window, LoWord(mResult), HiWord(mResult), TRUE);
  440.         SetRect(tempRect, 0, myPt.v - 15, myPt.h + 15, myPt.v + 15);
  441.         EraseRect(tempRect);
  442.         InvalRect(tempRect);
  443.         SetRect(tempRect, myPt.h - 15, 0, myPt.h + 15, myPt.v + 15);
  444.         EraseRect(tempRect);
  445.         InvalRect(tempRect);
  446.         Resize;
  447.     end;
  448.  
  449.     procedure WObject.Zoom (code: integer);
  450.         var
  451.             globalPortRect, theSect, zoomRect: Rect;
  452.             nthDevice, dominantGDevice: GDHandle;
  453.             sectFlag: boolean;
  454.             bias: integer;
  455.             greatestArea, sectArea: longInt;
  456.             tl, br: point;
  457.     begin
  458.         SetPort(window);
  459.         EraseRect(window^.portRect);    {recommended for cosmetic reasons}
  460.         if (code = inZoomOut) then begin
  461.             if sysenv.hasColorQD then begin
  462.                 globalPortRect := window^.portRect;
  463.                 LocalToGlobal(globalPortRect.topLeft);
  464.                 LocalToGlobal(globalPortRect.botRight);
  465.           { must calculate height of window's title bar }
  466.         { bias := globalPortRect.top - 1 - WindowPeek(window)^.strucRgn^^.rgnBBox.top; }
  467.         {   This doesn't work if the window is invisible, because structRgn is empty, and thus rgnBBox is 0,0,0,0 }
  468.                 bias := 18;
  469.                 nthDevice := GetDeviceList;
  470.                 greatestArea := -1;
  471.           { This loop checks the window against all the gdRects in the   }
  472.           { gDevice list and remembers which gdRect contains the largest }
  473.           { portion of the window being zoomed. }
  474.                 while nthDevice <> nil do begin
  475.                     sectFlag := SectRect(globalPortRect, nthDevice^^.gdRect, theSect);
  476.                     with theSect do
  477.                         sectArea := LONGINT(right - left) * (bottom - top);
  478.                     if sectArea > greatestArea then begin
  479.                         greatestArea := sectArea;
  480.                         dominantGDevice := nthDevice;
  481.                     end;
  482.                     nthDevice := GetNextDevice(nthDevice);
  483.                 end; {of WHILE}
  484.           { We must create a zoom rectangle manually in this case. }
  485.           { account for menu bar height as well, if on main device }
  486.                 if dominantGDevice = GetMainDevice then
  487.                     bias := bias + GetMBarHeight;
  488.                 with dominantGDevice^^.gdRect do
  489.                     SetRect(zoomRect, left + 3, top + bias + 3, right - 3, bottom - 3);
  490.             end {of Color QuickDraw conditional stuff}
  491.             else begin
  492.                 zoomRect := WStateDataHandle(WindowPeek(window)^.dataHandle)^^.stdState;
  493.             end;
  494.             tl := window^.portRect.topleft;
  495.             LocalToGlobal(tl);
  496.             br.v := tl.v + zoomSize.v;
  497.             br.h := tl.h + zoomSize.h;
  498.             with zoomRect do begin
  499.                 if PtInRect(tl, zoomRect) and PtInRect(br, zoomRect) then begin
  500.                     zoomRect.topleft := tl;
  501.                     zoomRect.botright := br;
  502.                 end
  503.                 else begin
  504.                     if right - left > zoomSize.h then
  505.                         right := left + zoomSize.h;
  506.                     if bottom - top > zoomSize.v then
  507.                         bottom := top + zoomSize.v;
  508.                 end;
  509.             end;
  510.        { Set up the WStateData record for this window. }
  511.             WStateDataHandle(WindowPeek(window)^.dataHandle)^^.stdState := zoomRect;
  512.         end;
  513.         ZoomWindow(window, code, true);
  514.         Resize;
  515.     end;
  516.  
  517.     procedure WObject.DoZoom (where: point; code: integer);
  518.     begin
  519.         SetPort(window);
  520.         if TrackBox(window, where, code) then
  521.             Zoom(code);
  522.     end;
  523.  
  524.     procedure WObject.DoGoAway (where: point);
  525.     begin
  526.         if TrackGoAway(window, where) then
  527.             DoClose;
  528.     end;
  529.  
  530.     procedure WObject.DoUpdate;
  531.     begin
  532.         BeginUpdate(window);
  533.         Draw;
  534.         EndUpdate(window);
  535.     end;
  536.  
  537.     procedure WObject.DoMouseMoved (where: point);
  538.     begin
  539.     end;
  540.  
  541.     procedure WObject.DoActivateDeactivate (activate: boolean);
  542.     begin
  543.         if activate then
  544.             SelectWindow(window);
  545.     end;
  546.  
  547.     procedure WObject.Resize;
  548.     begin
  549.     end;
  550.  
  551.     procedure WObject.Draw;
  552.     begin
  553.     end;
  554.  
  555.     function WObject.DoIsDialogEvent (er: eventRecord): boolean;
  556.     begin
  557.         DoIsDialogEvent := IsDialogEvent(er);
  558.     end;
  559.  
  560.     function WObject.DoDialogSelect (er: eventRecord; var dlg: dialogPtr; var item: integer): boolean;
  561.     begin
  562.         DoDialogSelect := DialogSelect(er, dlg, item);
  563.     end;
  564.  
  565.     procedure WObject.DoIdle;
  566.     begin
  567.     end;
  568.  
  569.     function WObject.DoMainClick (er: eventRecord): boolean;
  570.         var
  571.             b: boolean;
  572.             wp: windowPtr;
  573.             mResult: longInt;
  574.             code: integer;
  575.     begin
  576.         b := false;
  577.         code := FindWindow(er.where, wp);
  578.         if (wp <> nil) and (wp <> window) then begin
  579.             if (BAND(er.modifiers, cmdKey) = 0) or (code <> inDrag) then
  580.                 SelectWindow(wp);
  581.             if code = inDrag then
  582.                 GetWObject(wp).DoDrag(er.where);
  583.         end
  584.         else
  585.             case code of
  586.                 inMenuBar:  begin
  587.                     SetFMenus;
  588.                     mResult := MenuSelect(er.where);
  589.                     if mResult <> 0 then
  590.                         DoMenu(HiWord(mResult), LoWord(mResult), domenup);
  591.                 end;
  592.                 InDrag: 
  593.                     DoDrag(er.where);
  594.                 inGrow: 
  595.                     DoGrow(er.where);
  596.                 inZoomIn, inZoomOut: 
  597.                     DoZoom(er.where, code);
  598.                 inGoAway: 
  599.                     DoGoAway(er.where);
  600.                 inContent:  begin
  601.                     GlobalToLocal(er.where);
  602.                     DoContent(er.where);
  603.                 end;
  604.                 inSysWindow: 
  605.                     SystemClick(er, window);
  606.                 otherwise
  607.                     b := true;
  608.             end;
  609.         DoMainClick := b;
  610.     end;
  611.  
  612.     function WObject.HandleEvents (er: eventRecord): boolean;
  613.         var
  614.             wp: windowPtr;
  615.             b: boolean;
  616.             obj: WObject;
  617.             code: integer;
  618.             mResult: longInt;
  619.             myPt: point;
  620.             temprect: rect;
  621.             ch: char;
  622.             dlg: dialogPtr;
  623.             item: integer;
  624.     begin
  625.         DoIdle;
  626.         b := true;
  627.         if DoIsDialogEvent(er) then begin
  628.             if DoDialogSelect(er, dlg, item) then begin
  629.                 GetDObject(dlg).DoItemWhere(er, item);
  630.                 b := false;
  631.             end;
  632.         end;
  633.         if b then begin
  634.             b := false;
  635.             case er.what of
  636.                 MouseDown: 
  637.                     b := DoMainClick(er);
  638.  
  639.                 KeyDown:  begin
  640.                     ch := chr(BAND(er.message, CharCodeMask));
  641.                     mResult := 0;
  642.                     if BAND(er.modifiers, CmdKey) <> 0 then begin
  643.                         SetFMenus;
  644.                         mResult := DoMenuKey(er, ch);
  645.                     end;
  646.                     if mResult <> 0 then
  647.                         DoMenu(HiWord(mResult), LoWord(mResult), domenup)
  648.                     else
  649.                         DoSpecialKey(er.modifiers, ch, BAND(er.message, keyCodeMask) div $100);
  650.                 end;
  651.  
  652.                 AutoKey: 
  653.                     DoAutoKey(er.modifiers, chr(BAND(er.message, CharCodeMask)), BAND(er.message, keyCodeMask) div $100);
  654.  
  655.                 UpdateEvt: 
  656.                     GetWObject(windowPtr(er.message)).DoUpdate;
  657.  
  658.                 ActivateEvt: 
  659.                     GetWObject(windowPtr(er.message)).DoActivateDeactivate(odd(er.modifiers));
  660.  
  661.                 kOSEvent: 
  662.                     if BAND(BROTL(er.message, 8), $FF) = kSuspendResumeMessage then
  663.                         DoSuspendResume(BAnd(er.message, kResumeMask) <> 0)
  664.                     else if BAND(BROTL(er.message, 8), $FF) = kMouseMovedMessage then
  665.                         DoMouseMoved(er.where)
  666.                     else
  667.                         b := true;
  668.  
  669.                 kHighLevelEvent: 
  670.                     DoHighLevel(er);
  671.  
  672.                 DiskEvt: 
  673.                     DoDiskEvent(er.message);
  674.  
  675.                 otherwise
  676.                     b := true;
  677.             end;
  678.         end;
  679.         HandleEvents := b;
  680.     end;
  681.  
  682.     procedure DObject.Create (id: integer);
  683.         var
  684.             wp: myDialogPtr;
  685.     begin
  686.         wp := myDialogPtr(NewPtr(SizeOf(myDialogRecord)));
  687.         wp^.magic := OOMagic;
  688.         window := GetNewDialog(id, ptr(wp), POINTER(-1));
  689.         ok_item := 0;
  690.         cancel_item := 0;
  691.         JointCreate(self);
  692.     end;
  693.  
  694.     procedure DObject.Destroy;
  695.     begin
  696.         if window <> nil then
  697.             DisposDialog(window);
  698.         if self <> default_object then
  699.             dispose(self);
  700.     end;
  701.  
  702.     procedure DObject.DoOK (modifiers: integer; ch: char; code: integer);
  703.     begin
  704.         if ok_item = 0 then
  705.             DoKey(modifiers, ch, code)
  706.         else begin
  707.             if ControlEnabled(window, ok_item) then begin
  708.                 FlashItem(window, ok_Item);
  709.                 DoItem(ok_item);
  710.             end;
  711.         end;
  712.     end;
  713.  
  714.     procedure DObject.DoCancel (modifiers: integer; ch: char; code: integer);
  715.     begin
  716.         if cancel_item = 0 then
  717.             DoKey(modifiers, ch, code)
  718.         else begin
  719.             FlashItem(window, cancel_Item);
  720.             DoItem(cancel_item);
  721.         end;
  722.     end;
  723.  
  724.     procedure DObject.DoItem (item: integer);
  725.     begin
  726.     end;
  727.  
  728.     procedure DObject.DoItemWhere (er: eventRecord; item: integer);
  729.     begin
  730.         DoItem(item);
  731.     end;
  732.  
  733.     function DObject.HandleEvents (er: eventRecord): boolean;
  734.         var
  735.             b: boolean;
  736.             ch: char;
  737.     begin
  738.         b := true;
  739.         if ((er.what = KeyDown) or (er.what = AutoKey)) then begin
  740.             b := false;
  741.             ch := chr(BAND(er.message, charCodeMask));
  742.             if (ch = chr(13)) or (ch = chr(3)) then
  743.                 DoOK(er.modifiers, ch, BAND(er.message, keyCodeMask) div $100)
  744.             else if (ch = chr(27)) or ((ch = '.') and (BAND(er.modifiers, cmdKey) <> 0)) then
  745.                 DoCancel(er.modifiers, ch, BAND(er.message, keyCodeMask) div $100)
  746.             else
  747.                 b := true;
  748.         end;
  749.         if b then
  750.             b := inherited HandleEvents(er);
  751.         HandleEvents := b;
  752.     end;
  753.  
  754.     procedure DTObject.SetEditMenuItem (item: integer);
  755.     begin
  756.         TESetEditMenuItem(dialogPeek(window)^.textH, false, 250, item);
  757.     end;
  758.  
  759.     function DTObject.EditMenuEnabled: boolean;
  760.     begin
  761.         EditMenuEnabled := TEEditMenuEnabled(dialogPeek(window)^.textH, false, 250);
  762.     end;
  763.  
  764.     procedure DTObject.DoEditMenu (item: integer);
  765.         var
  766.             modified: boolean;
  767.     begin
  768.         modified := TEDoEditMenu(dialogPeek(window)^.textH, false, 250, item);
  769.     end;
  770.  
  771.     function DTObject.DoIsDialogEvent (er: eventRecord): boolean;
  772.     begin
  773.         if ((er.what = keyDown) or (er.what = autoKey)) and (BAND(er.modifiers, cmdKey) <> 0) then begin
  774.             DoIsDialogEvent := false; { Stop system 7 from doing the edit menu as well }
  775.         end
  776.         else
  777.             DoIsDialogEvent := inherited DoIsDialogevent(er);
  778.     end;
  779.  
  780. end.